#ifndef PRUEBABLOQUEBSHARP_H_
#define PRUEBABLOQUEBSHARP_H_

#include "../BloqueBSharp.h"
#include "../includes.h"
#include "../DatoBSharp.h"
#include "ClaveAlumno.h"
#include "../Registro.h"
#include "../Archivo.h"

#include "ClaveVariable.h"
#include "ClaveChar.h"

using namespace Toolkit;

int ingresarElementos(BloqueBSharp &bloqueBSharp, unsigned long int limite,
					   TipoSerializacion tSerializacion, unsigned int comienzo)
{
	int i = 0;

	while (bloqueBSharp.getTamanoSerializacion() < limite)
	{
		ClaveAlumno clave(comienzo + i, tSerializacion);
		DatoBSharp datoBSharp(clave, comienzo + 3*i, tSerializacion);

		Registro *registro = new Registro(tSerializacion);
		registro->setDato(datoBSharp);

		bloqueBSharp.agregar(registro, clave);

		i++;
	}

	return (--i);
}


void pruebaDxBalancearEnDos()
{
	int tamanoBloque = 600;
	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp bloqueBSharp1(tamanoBloque, tSerializacion);

	BloqueBSharp bloqueBSharp2(tamanoBloque, tSerializacion);

	ingresarElementos(bloqueBSharp1, 600, tSerializacion, 10);
	ingresarElementos(bloqueBSharp2, 400, tSerializacion, 100);//

	cout << "tamano Serializacion bloque 1: " << bloqueBSharp1.getTamanoSerializacion() << endl;
	cout << "tamano Serializacion bloque 2: " << bloqueBSharp2.getTamanoSerializacion() << endl;

	bool sePuede = bloqueBSharp1.sePuedeBalancearEnDos(bloqueBSharp2);

	cout << "se puede: " << sePuede << endl;

	bloqueBSharp1.balancearEnDos(bloqueBSharp2);

	cout << "tamano Serializacion bloque 1: " << bloqueBSharp1.getTamanoSerializacion() << endl;
	cout << "tamano Serializacion bloque 2: " << bloqueBSharp2.getTamanoSerializacion() << endl;

}

void pruebaBusquedaSimple()
{
	int tamanoBloque = 600;
	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp bloqueBSharp(tamanoBloque, tSerializacion);

	ClaveAlumno clave(15, tSerializacion);
	DatoBSharp datoBSharp(clave, 30, tSerializacion);

	Registro *registro = new Registro(tSerializacion);
	registro->setDato(datoBSharp);

	bloqueBSharp.agregar(registro, clave);

	Registro* registroNoNull = (Registro*)bloqueBSharp.buscar(clave);

	if (registroNoNull == NULL)
	{
		cout << "explota todo" << endl;
	} else {
		cout << "nice" << endl;
		DatoBSharp *datoB = (DatoBSharp*)registroNoNull->clonarDato();
		cout << "padron: " << ((ClaveAlumno*)(datoB->getClave()))->getPadron() << endl;
	}
}


void pruebaPartirRaiz()
{
	int tamanoBloque = 600;
	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp raiz(tamanoBloque, tSerializacion);

	unsigned long int cuatroTerciosTamano = tamanoBloque * 4 / 3;
	cout << "cuatro tercios del tamano de un bloque es: " << cuatroTerciosTamano << endl;

	int cantidadIngresada = ingresarElementos(raiz, cuatroTerciosTamano, tSerializacion, 0);

	cout << "despues de ingresar elementos, el tamano de la raiz es: "
	<< raiz.getTamanoSerializacion() << endl;
	cout << "y su cantidad de elementos es: " << raiz.cantElementos() << endl;

	BloqueBSharp *bloqueNuevo = raiz.partirRaiz();

	cout << "luego de partir :" << endl;
	cout << "cantidad de elementos del bloque nuevo es: " << bloqueNuevo->cantElementos() << endl;
	cout << "cantidad de elementos del bloque viejo es: " << raiz.cantElementos() << endl;

	cout << "tamano serializacion del bloque nuevo es: " << bloqueNuevo->getTamanoSerializacion() << endl;
	cout << "tamano serializacion del bloque viejo es: " << raiz.getTamanoSerializacion() << endl;

	int cantidadErrores = 0;

	//verifico que sean los elementos correctos
	while (bloqueNuevo->cantElementos() > 0)
	{
		Registro *registro = (Registro*)bloqueNuevo->popBack();
		DatoBSharp *dato = (DatoBSharp*)registro->clonarDato();
		ClaveAlumno *clave = (ClaveAlumno*)dato->getClave();

		ClaveAlumno claveAcomparar(cantidadIngresada, tSerializacion);

		cout << "padron: " << clave->getPadron() << endl;

		if ((*clave) != claveAcomparar)
		{
			cantidadErrores++;
		}

		cantidadIngresada--;

		delete dato;
		delete registro;
	}

	if (cantidadErrores == 0)
	{
		cout << "se parte correctamente";
	} else {
		cout << "se parte incorrectamente";
	}

	delete bloqueNuevo;
}

void pruebaUnirRaiz()
{
	int tamanoBloque = 600;
	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp bloqueB(tamanoBloque, tSerializacion);

	ingresarElementos(bloqueB, tamanoBloque/2, tSerializacion, 0);

	BloqueBSharp bloqueBnuevo(tamanoBloque, tSerializacion);

	ClaveAlumno clave(100, tSerializacion);
	DatoBSharp datoBSharp(clave, 200, tSerializacion);
	Registro *registro = new Registro(tSerializacion);
	registro->setDato(datoBSharp);
	bloqueBnuevo.agregar(registro, clave);

//	cout << "antes de unir:" << endl;
//	cout << "cantidad elementos bloque nuevo: " << bloqueBnuevo.cantElementos() << endl;
//	cout << "cantidad elementos bloque viejo: " << bloqueB.cantElementos() << endl;

	bloqueBnuevo.unirRaiz(bloqueB);

	cout << "despues de unir:" << endl;
	cout << "cantidad elementos bloque nuevo: " << bloqueBnuevo.cantElementos() << endl;
	cout << "cantidad elementos bloque viejo: " << bloqueB.cantElementos() << endl;

//	list<unsigned long int> listita = bloqueB.imprimirYPoisciones();
//
//    list<unsigned long int>::iterator it = listita.begin();
//
//    //TODO: utilizar listita de joe
//
//    while (it != listita.end())
//    {
//    	cout << (*it) << endl;
//    	it++;
//    }

	while (bloqueBnuevo.cantElementos() > 0)
	{
		Registro *registro = (Registro*)bloqueBnuevo.popBack();
		DatoBSharp *dato = (DatoBSharp*)registro->clonarDato();
		ClaveAlumno *clave = (ClaveAlumno*)dato->getClave();

		cout << "el padron de la clave que saco es: " << clave->getPadron() << endl;

		delete registro;
		delete dato;
	}
}

/***************************************/
//tiene que ser mayor a 14, para contemplar la metadata de las cosas
Registro *getRegistroTamano(const unsigned long int &tamano, const char &letra, Clave *&clave,
	const unsigned long int &sucesor = 0) {
	clave = new ClaveVariable(tamano - 9, letra); //super hardcodeado
	DatoBSharp dato(*clave, sucesor, TEXTO);
	Registro *registro = new Registro (TEXTO);
	registro->setDato(dato);

	return registro;
}

Registro *getRegistroChar(TipoSerializacion tser, const char &letra, Clave *&clave, const unsigned long int &sucesor = 0) {

	clave = new ClaveChar(letra);
	DatoBSharp dato(*clave, sucesor, tser);
	Registro *registro = new Registro(tser);
	registro->setDato(dato);

	return registro;
}

void pruebaOverflowUnderflow()
{
	TipoSerializacion tSerializacion = TEXTO;
	BloqueBSharp bloque(200, tSerializacion);

	//arranca con 13 bytes
	bool paso = true;
	paso = bloque.estaUnderflow();
	paso = ((paso) && (!bloque.estaOverflow()));

	Clave *clave = NULL;

	//Se le van sumando los bytes que le pido al registro
	Registro *registro = getRegistroTamano(25, 'a', clave);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(41, 'c', clave);
	bloque.agregar(registro, *clave);
	delete clave;

	paso = ((paso) && (bloque.estaUnderflow()));
	paso = ((paso) && (!bloque.estaOverflow()));

	registro = getRegistroTamano(53, 'b', clave);
	bloque.agregar(registro, *clave);
	delete clave;

	paso = ((paso) && (bloque.estaUnderflow()));
	paso = ((paso) && (!bloque.estaOverflow()));

	registro = getRegistroTamano(25, 'd', clave);
	bloque.agregar(registro, *clave);
	delete clave;
	paso = ((paso) && (!bloque.estaUnderflow()));
	paso = ((paso) && (!bloque.estaOverflow()));

	registro = getRegistroTamano(50, 'e', clave);
	bloque.agregar(registro, *clave);
	delete clave;
	paso = ((paso) && (!bloque.estaUnderflow()));
	paso = ((paso) && (bloque.estaOverflow()));


	if (paso) {
		cout << "anduvo bien el OF Y UF " << endl;
	} else {
		cout << "ANDUVO MAL!! el OF Y UF " << endl;
	}
}

void pruebaNodoSiguiente()
{
	TipoSerializacion tSerializacion = TEXTO;
	BloqueBSharp bloque(200, tSerializacion);
	unsigned long int sucIzq = 17;
	bloque.setDireccion(sucIzq);
	bloque.setNivelNodo(1);

	Clave *clave;
	Registro *registro;

	unsigned long int sucC = 5;
	unsigned long int sucE = 32;
	unsigned long int sucG = 9;

	registro = getRegistroTamano(25, 'C', clave, sucC);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'E', clave, sucE);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'G', clave, sucG);
	bloque.agregar(registro, *clave);
	delete clave;

	bool paso = true;
	clave = new ClaveVariable(10, 'B');
	paso = (bloque.nodoSiguiente(*clave) == sucC);

	delete clave;
	clave = new ClaveVariable(10, 'D');
	paso = ((paso)&&(bloque.nodoSiguiente(*clave) == sucE));

	delete clave;
	clave = new ClaveVariable(10, 'C');
	paso = ((paso)&&(bloque.nodoSiguiente(*clave) == sucC));


	delete clave;
	clave = new ClaveVariable(10, 'G');
	paso = ((paso)&&(bloque.nodoSiguiente(*clave) == sucG));

	delete clave;
	clave = new ClaveVariable(10, 'M');
	paso = ((paso)&&(bloque.nodoSiguiente(*clave) == sucG));

	bloque.setNivelNodo(0);

	paso = ((paso)&&(bloque.nodoSiguiente(*clave) == sucIzq));

	delete clave;

	if (paso) {
		cout << "anduvo bien nodo siguiente " << endl;
	} else {
		cout << "ANDUVO MAL!! nodo siguiente " << endl;
	}
}

void pruebaSerializacion() {

	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp bloque(200, tSerializacion);
	unsigned long int sucIzq = 17;
	bloque.setDireccion(sucIzq);

	Clave *clave;
	Registro *registro;

	registro = getRegistroTamano(25, 'C', clave, 5);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'E', clave, 32);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'G', clave, 9);
	bloque.agregar(registro, *clave);

	stringstream serializacion;
	bloque.serializar(serializacion);

	BloqueBSharp otro(200, tSerializacion);
	DatoBSharp dato((*clave), 15, tSerializacion);
	otro.hidratar(serializacion, dato);
	delete clave;

	bool paso = true;
	paso = (otro.getDireccion() == bloque.getDireccion());

	registro = (Registro*) bloque.popBack();
	DatoBSharp *datoReg = (DatoBSharp*)registro->clonarDato();
	paso = ((paso)&&(((ClaveVariable*)datoReg->getClave())->getLetra() == 'G'));

	delete datoReg;
	delete registro;

	registro = (Registro*) bloque.popBack();
	datoReg = (DatoBSharp*)registro->clonarDato();
	paso = ((paso)&&(((ClaveVariable*)datoReg->getClave())->getLetra() == 'E'));

	delete datoReg;
	delete registro;

	if (paso) {
		cout << "anduvo bien serializacion " << endl;
	} else {
		cout << "ANDUVO MAL!! serializacion " << endl;
	}
}

void pruebaBalancearEnDos()
{
	//arrancan con 21 bytes	en mi casa.
	//aca son 13
	TipoSerializacion tSerializacion = TEXTO;

	bool paso = true;
	Clave *clave;
	Registro *registro;
	BloqueBSharp *bloque1, *bloque2;

	//Underflow - sobran
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(25, 'b', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(58, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(70, 'e', clave);
	bloque2->agregar(registro, *clave);
	cout << bloque1->getTamanoSerializacion()<< endl;
	cout << bloque2->getTamanoSerializacion()<< endl;

	paso = ((paso) && (bloque1->sePuedeBalancearEnDos(*bloque2)));

	cout << paso << endl;
	bloque1->balancearEnDos(*bloque2);
	paso = (paso && (!bloque1->estaUnderflow() && !bloque2->estaUnderflow()));

		cout << paso << endl;
	delete bloque1;
	delete bloque2;

	//al revés
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(45, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(30, 'c', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(45, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(78, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (bloque1->sePuedeBalancearEnDos(*bloque2)));

		cout << paso << endl;
	paso = (paso && (!bloque1->estaUnderflow() && !bloque2->estaUnderflow()));

		cout << paso << endl;

	delete bloque1;
	delete bloque2;

	//Underflow - justo
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(25, 'b', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(58, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(38, 'd', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (!bloque1->sePuedeBalancearEnDos(*bloque2)));

	delete bloque1;
	delete bloque2;

	//Underflow - sobran pero con un bloque grande
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(120, 'b', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(58, 'c', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (!bloque1->sePuedeBalancearEnDos(*bloque2)));

	delete bloque1;
	delete bloque2;

	//overflow - tiene lugar
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(75, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'c', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(50, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(78, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (bloque1->sePuedeBalancearEnDos(*bloque2)));
	bloque1->balancearEnDos(*bloque2);
	paso = (paso && (!bloque1->estaOverflow() && !bloque2->estaOverflow()));

	delete bloque1;
	delete bloque2;

	//al reves
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'b', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(50, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(70, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(78, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (bloque1->sePuedeBalancearEnDos(*bloque2)));
	bloque1->balancearEnDos(*bloque2);
	paso = (paso && (!bloque1->estaOverflow() && !bloque2->estaOverflow()));

	delete bloque1;
	delete bloque2;

	//underflow - overflow	y se arregla
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(88, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'b', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(50, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(70, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(78, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (bloque1->sePuedeBalancearEnDos(*bloque2)));
	bloque1->balancearEnDos(*bloque2);
	paso = (paso && (!bloque1->estaOverflow() && !bloque2->estaOverflow()));

	//underflow - overflow	y NO se arregla
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(88, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'b', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(90, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(108, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (!bloque1->sePuedeBalancearEnDos(*bloque2)));

	//underflow - underflow
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(25, 'b', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(58, 'c', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'd', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (!bloque1->sePuedeBalancearEnDos(*bloque2)));

	delete bloque1;
	delete bloque2;

	//overflow - overflow
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(75, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'c', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(90, 'd', clave);
	bloque2->agregar(registro, *clave);
	registro = getRegistroTamano(98, 'e', clave);
	bloque2->agregar(registro, *clave);

	paso = ((paso) && (!bloque1->sePuedeBalancearEnDos(*bloque2)));

	delete bloque1;
	delete bloque2;


	if (paso) {
		cout << "anduvo bien balanceo entre 2 " << endl;
	} else {
		cout << "ANDUVO MAL!! balanceo entre 2 " << endl;
	}
}

void pruebaBalancearEnTres()
{
	//arrancan con 13 bytes
	TipoSerializacion tSerializacion = TEXTO;

	bool paso = true;
	Clave *clave;
	Registro *registro;
	BloqueBSharp *bloque1, *bloque2, *bloque3;

	//of - lleno (no queda en uf)
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);
	bloque3 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'c', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'd', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(50, 'e', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(75, 'f', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'g', clave);
	bloque3->agregar(registro, *clave);

	paso = ((paso)&&(bloque1->sePuedeBalancearEnTres(*bloque2, *bloque3)));
	bloque1->balancearEnTres(*bloque2, *bloque3);
	paso = ((paso)&&(!bloque1->estaOverflow())&&(!bloque1->estaUnderflow()));
	paso = ((paso)&&(!bloque2->estaOverflow())&&(!bloque2->estaUnderflow()));
	paso = ((paso)&&(!bloque3->estaUnderflow()));

	delete bloque1;
	delete bloque2;
	delete bloque3;

	//al reves
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);
	bloque3 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(90, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(40, 'c', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(25, 'd', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(40, 'e', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'f', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'g', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(80, 'h', clave);
	bloque3->agregar(registro, *clave);

	paso = ((paso)&&(bloque1->sePuedeBalancearEnTres(*bloque2, *bloque3)));
	bloque1->balancearEnTres(*bloque2, *bloque3);
	paso = ((paso)&&(!bloque1->estaOverflow())&&(!bloque1->estaUnderflow()));
	paso = ((paso)&&(!bloque2->estaOverflow())&&(!bloque2->estaUnderflow()));
	paso = ((paso)&&(!bloque3->estaUnderflow()));

	delete bloque1;
	delete bloque2;
	delete bloque3;

	//of - lleno (queda en uf)
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);
	bloque3 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(108, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'c', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'd', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(50, 'e', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(75, 'f', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(42, 'g', clave);
	bloque3->agregar(registro, *clave);

	paso = ((paso)&&(!bloque1->sePuedeBalancearEnTres(*bloque2, *bloque3)));
	bloque1->balancearEnTres(*bloque2, *bloque3);
	paso = ((paso)&&(!bloque1->estaOverflow())&&(!bloque1->estaUnderflow()));
	paso = ((paso)&&(!bloque2->estaOverflow())&&(!bloque2->estaUnderflow()));
	paso = ((paso)&&(bloque3->estaUnderflow()));

	delete bloque1;
	delete bloque2;
	delete bloque3;

	//al reves
	bloque1 = new BloqueBSharp(200, tSerializacion);
	bloque2 = new BloqueBSharp(200, tSerializacion);
	bloque3 = new BloqueBSharp(200, tSerializacion);

	registro = getRegistroTamano(90, 'a', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'b', clave);
	bloque1->agregar(registro, *clave);
	registro = getRegistroTamano(40, 'c', clave);
	bloque1->agregar(registro, *clave);

	registro = getRegistroTamano(25, 'd', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(40, 'e', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(25, 'f', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(50, 'g', clave);
	bloque3->agregar(registro, *clave);
	registro = getRegistroTamano(30, 'h', clave);
	bloque3->agregar(registro, *clave);

	paso = ((paso)&&(!bloque1->sePuedeBalancearEnTres(*bloque2, *bloque3)));
	bloque1->balancearEnTres(*bloque2, *bloque3);
	paso = ((paso)&&(!bloque1->estaOverflow())&&(!bloque1->estaUnderflow()));
	paso = ((paso)&&(!bloque2->estaOverflow())&&(!bloque2->estaUnderflow()));
	paso = ((paso)&&(bloque3->estaUnderflow()));

	delete bloque1;
	delete bloque2;
	delete bloque3;

	if (paso) {
		cout << "anduvo bien balanceo entre 3 " << endl;
	} else {
		cout << "ANDUVO MAL!! balanceo entre 3 " << endl;
	}
}

void pruebaObtenerSiblings()
{
	TipoSerializacion tSerializacion = TEXTO;

	BloqueBSharp bloque(200, tSerializacion);
	unsigned long int sucIzq = 17;
	bloque.setDireccion(sucIzq);

	Clave *clave;
	Registro *registro;

	unsigned long int sucC = 5;
	unsigned long int sucE = 32;
	unsigned long int sucG = 9;

	registro = getRegistroTamano(25, 'C', clave, sucC);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'E', clave, sucE);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'G', clave, sucG);
	bloque.agregar(registro, *clave);
	delete clave;

	ClaveVariable claveE(16, 'E');
	ClaveVariable claveG(16, 'G');
	ClaveVariable claveC(16, 'C');

	if ((bloque.siblingDerecho(claveE) == 9) && (bloque.siblingDerecho(claveG)) == -1)
	{
		cout << "busca bien el sibling derecho" << endl;
	} else {
		cout << "busca mal el sibling derecho" << endl;
	}

	if ((bloque.siblingIzquierdo(claveG) == 32) && (bloque.siblingIzquierdo(claveE) == 5)
		&& (bloque.siblingIzquierdo(claveC) == -1))
	{
		cout << "busca bien el sibling izquierdo";
	} else {
		cout << "busca mal el sibling izquierdo";
	}

}

void pruebaOverflowRaiz()
{
	TipoSerializacion tSerializacion = TEXTO;
	BloqueBSharp bloque(600, tSerializacion);
	ingresarElementos(bloque,800, tSerializacion, 0);

	cout << bloque.getTamanoSerializacion() << endl;

	if (bloque.estaOverflowRaiz())
	{
		cout << "chequea bien el overflow";
	} else {
		cout << "chequea mal el overflow";
	}
}

void pruebaSePuedeUnirRaiz()
{
	TipoSerializacion tSerializacion = TEXTO;
	BloqueBSharp bloqueRaiz(600, tSerializacion);
	BloqueBSharp bloque(600, tSerializacion);

	unsigned long int tamanoSerializacion = bloqueRaiz.getTamanoSerializacion();
	cout << "tamano bloque vacio: " << tamanoSerializacion << endl;

	ingresarElementos(bloque,400, tSerializacion, 0);
	ingresarElementos(bloqueRaiz,400, tSerializacion, 400);

	bool sePuedeUnir = bloqueRaiz.sePuedeUnirRaiz(bloque);

	cout << "antes de unir:" << endl;
	cout << "bloque raiz: " << bloqueRaiz.getTamanoSerializacion() << endl;
	cout << "bloque normal: " << bloque.getTamanoSerializacion() << endl;

	cout << "despues de unir:" << endl;
	bloqueRaiz.unirRaiz(bloque);
	cout << "bloque raiz: " << bloqueRaiz.getTamanoSerializacion() << endl;
	cout << "bloque normal: " << bloque.getTamanoSerializacion() << endl;

	if (sePuedeUnir && (bloqueRaiz.getTamanoSerializacion() < 800))
	{
		cout << "funciona bien" << endl;
	} else {
		cout << "funciona mal" << endl;
	}
}

void pruebaSePuedeUnirTresEnDos()
{
	TipoSerializacion tSerializacion = TEXTO;

	int tamanoBloque = 600;

	BloqueBSharp bloque1(tamanoBloque, tSerializacion);
	BloqueBSharp bloque2(tamanoBloque, tSerializacion);
	BloqueBSharp bloque3(tamanoBloque, tSerializacion);

	unsigned long int tamanoBloqueVacio = bloque1.getTamanoSerializacion();

	ingresarElementos(bloque1, 380, tSerializacion, 0);
	ingresarElementos(bloque2, 400, tSerializacion, 100);
	ingresarElementos(bloque3, 400, tSerializacion, 200);
	cout << "cantidad elementos: " << bloque1.cantElementos();

	cout << "antes de unir: " << endl;
	cout << "tamano serializacion 1: " << bloque1.getTamanoSerializacion() << endl;
	cout << "tamano serializacion 2: " << bloque2.getTamanoSerializacion() << endl;
	cout << "tamano serializacion 3: " << bloque3.getTamanoSerializacion() << endl;

	bool sePuedeUnir = bloque1.sePuedeUnirTresEnDos(bloque2, bloque3);
	cout << "se puede unir: " << sePuedeUnir<< endl;

	int calculoFeo = bloque1.getTamanoSerializacion() + bloque2.getTamanoSerializacion()
					 + bloque3.getTamanoSerializacion() - tamanoBloqueVacio;

	if (sePuedeUnir == (calculoFeo < 1200)){
		cout << "funciona bien el metodo se puede unir 3 en 2" << endl;
	} else {
		cout << "funciona mal el metodo se puede unir 3 en 2" << endl;
	}

	//falta verificar si mando 1 solo registro MUY GRANDE.

	bloque1.unirTresEnDos(bloque2, bloque3);

	cout << "despues de unir: " << endl;
	cout << "tamano serializacion 1: " << bloque1.getTamanoSerializacion() << endl;
	cout << "tamano serializacion 2: " << bloque2.getTamanoSerializacion() << endl;
	cout << "tamano serializacion 3: " << bloque3.getTamanoSerializacion() << endl;
}

void pruebaClaveMaxima()
{
	TipoSerializacion tSerializacion = TEXTO;
	BloqueBSharp bloque(200, tSerializacion);
	unsigned long int sucIzq = 17;
	bloque.setDireccion(sucIzq);

	bool resultado = true;

	Clave* soyNulo = bloque.claveMaxima();
	resultado = resultado && (soyNulo == NULL);

	if (soyNulo != NULL){ delete soyNulo;}

	Clave *clave;
	Registro *registro;

	unsigned long int sucC = 5;
	unsigned long int sucE = 32;
	unsigned long int sucG = 9;

	registro = getRegistroTamano(25, 'C', clave, sucC);
	bloque.agregar(registro, *clave);

	Clave* soyClaveC = bloque.claveMaxima();

	resultado = resultado && ((*soyClaveC) == (*clave));

	delete clave;

	registro = getRegistroTamano(25, 'E', clave, sucE);
	bloque.agregar(registro, *clave);
	delete clave;
	registro = getRegistroTamano(25, 'G', clave, sucG);
	bloque.agregar(registro, *clave);

	Clave* soyClaveG = bloque.claveMaxima();

	resultado = resultado && ((*soyClaveG) == (*clave));

	delete clave;

	if (resultado)
	{
		cout << "good, funciona clave maxima";
	} else {
		cout << ":(, no funciona clave maxima";
	}
}

void armarArbol() {

	TipoSerializacion tser = TEXTO;
	list<Clave *> listaDeClaves;
	DatoBSharp datoMolde( ClaveChar('D'), 0, tser);

	Registro regAux(tser);
	regAux.setDato( DatoBSharp( ClaveChar('C'), 666, tser) );
	int tamanoregistro = regAux.getTamanoSerializacion();//TODO: Borrar gettamanoserializa de clave
	int tamanobloque = 4*tamanoregistro + BloqueBSharp(666, tser).getTamanoSerializacion();
	BloqueBSharp * bloqueActual = new BloqueBSharp(tamanobloque, tser);
	Clave *claveActual;
	unsigned long int dirIPZ, dirDGI, dirMP, dirTXZ, dirABCD, dirJKLM,
                      dirQRST, dirYZ, dirEFG, dirHI, dirNOP, dirUVWX;

	bloqueActual->setNivelNodo(0);
	std::stringstream stream;
	stream.str("|prueba armado de arbol B|");
	Archivo persistencia (tamanobloque, "./test/", "pruebaArbolArmado", tser, stream, tser);

	//Nuevo Bloque, letras Y Z.
	Registro *regActual = getRegistroChar(tser, 'Y', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	stringstream serializacion;
	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirYZ = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras U V W X.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'V', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'W', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'X', claveActual, dirYZ);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'U', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirUVWX = persistencia.guardarDato(serializacion);
	delete bloqueActual;

	//Nuevo Bloque, letras Q R S T.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'S', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'R', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'Q', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'T', claveActual, dirUVWX);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirQRST = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras N O P.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'P', claveActual, dirQRST);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'O', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'N', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirNOP = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras J K L M.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'J', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'K', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'L', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'M', claveActual, dirNOP);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirJKLM = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras H I.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'I', claveActual, dirJKLM);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'H', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirHI = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras E F G.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'F', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'G', claveActual, dirHI);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'E', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirEFG = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras A B C D.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(0);

	regActual = getRegistroChar(tser, 'B', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'A', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'D', claveActual, dirEFG);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'C', claveActual, 0);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirABCD = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	// Recupero a YZ y le agrego la Z q faltaba, apuntandola al primer bloque.

	serializacion.str("");
	persistencia.recuperarDato(dirYZ, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	regActual = getRegistroChar( tser, 'Z', claveActual, dirABCD);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	persistencia.guardarDato(serializacion, dirYZ);
	delete bloqueActual;

	// Comienza creacion de nodos indice:

	//Nuevo Bloque, letras D G I.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(1);

	regActual = getRegistroChar(tser, 'G', claveActual, dirEFG);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'D', claveActual, dirABCD);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'I', claveActual, dirHI);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirDGI = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras M P.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(1);

	regActual = getRegistroChar(tser, 'M', claveActual, dirJKLM);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'P', claveActual, dirNOP);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirMP = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	//Nuevo Bloque, letras T X Z.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(1);

	regActual = getRegistroChar(tser, 'T', claveActual, dirQRST);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'Z', claveActual, dirYZ);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar(tser, 'X', claveActual, dirUVWX);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirTXZ = persistencia.guardarDato(serializacion);
	delete bloqueActual;


	// Creacion de nodo RAIZ

	// Bloque raiz, letras I P Z.
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->setNivelNodo(2);

	regActual = getRegistroChar( tser, 'I', claveActual, dirDGI);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar( tser, 'P', claveActual, dirMP);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	regActual = getRegistroChar( tser, 'Z', claveActual, dirTXZ);
	listaDeClaves.push_front(claveActual);
	bloqueActual->agregar(regActual, *claveActual);

	serializacion.str("");
	bloqueActual->serializar(serializacion);
	dirIPZ = persistencia.guardarDato(serializacion);
	delete bloqueActual;



//TODO Falta setearles a todos su direccion!!!!

	// Comienza verificacion de consistencia de la prueba...

	bool consistencia = true;
	Registro *resultado;


// Prueba bloque ABCD
	serializacion.str("");
	persistencia.recuperarDato(dirABCD, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);

	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('D'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirEFG);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('A'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('B'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('C'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque EFG
	serializacion.str("");
	persistencia.recuperarDato(dirEFG, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('E'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('F'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('G'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirHI);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque HI
	serializacion.str("");
	persistencia.recuperarDato(dirHI, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('H'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('I'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirJKLM);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque JKLM
	serializacion.str("");
	persistencia.recuperarDato(dirJKLM, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('J'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('K'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('L'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('M'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirNOP);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque NOP
	serializacion.str("");
	persistencia.recuperarDato(dirNOP, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('N'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('O'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('P'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirQRST);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque QRST
	serializacion.str("");
	persistencia.recuperarDato(dirQRST, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('Q'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('R'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('S'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('T'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirUVWX);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque UVWX
	serializacion.str("");
	persistencia.recuperarDato(dirUVWX, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('U'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('V'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('W'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('X'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirYZ);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque YZ
	serializacion.str("");
	persistencia.recuperarDato(dirYZ, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('Y'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == 0);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('Z'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirABCD);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


//Prueba nodos indice:

// Prueba bloque DGI
	serializacion.str("");
	persistencia.recuperarDato(dirDGI, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('D'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirABCD);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('G'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirEFG);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('I'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirHI);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque MP
	serializacion.str("");
	persistencia.recuperarDato(dirMP, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('M'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirJKLM);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('P'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirNOP);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba bloque TXZ
	serializacion.str("");
	persistencia.recuperarDato(dirTXZ, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('T'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirQRST);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('X'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirUVWX);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('Z'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirYZ);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


// Prueba Raiz

// Prueba bloque IPZ
	serializacion.str("");
	persistencia.recuperarDato(dirIPZ, serializacion);
	bloqueActual = new BloqueBSharp(tamanobloque, tser);
	bloqueActual->hidratar(serializacion, datoMolde);

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('I'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirDGI);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('P'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirMP);
			delete datoResultante;
		}
	else consistencia = false;

	resultado = (Registro*)bloqueActual->buscar(ClaveChar('Z'));
	if ( resultado != NULL )
		{
			DatoBSharp *datoResultante = (DatoBSharp*) resultado->clonarDato();
			consistencia =  consistencia && (datoResultante->getPosicion() == dirTXZ);
			delete datoResultante;
		}
	else consistencia = false;

	delete bloqueActual;


if (consistencia)
	cout<<"Consistencia verificada"<<endl;
else
	cout<<"Problema de consistencia"<<endl;

	cout<<"a partir de aca, se pueden hacer las pruebas de los metodos con el arbol armado";
}



#endif /* PRUEBABLOQUEBSHARP_H_ */

